package ljl.codetop300;

import java.util.Arrays;

/**
 * 翻转整数，我一看，就知道是在考察边界处理
 */
public class _7_reverse_number {

  static class easy {
    public int reverse(int x) {
      if (x == 0) return 0;
      int sign = x < 0 ? -1 : 1;

      String str = String.valueOf(x);
      // 去掉符号
      if (str.charAt(0) == '+' || str.charAt(0) == '-') {
        str = str.substring(1);
      }
      // 反转
      StringBuilder sb = new StringBuilder(str);
      sb.reverse();
      // 去掉开头的 0
      int i = 0;
      while (sb.charAt(i) == '0') i++;
      long value = Long.parseLong(sb.substring(i));
      // 规定超范围返回 0
      if (value > Integer.MAX_VALUE) return 0;
      return sign * (int) value;
    }
  }

  static class better {
    public static void main(String[] args) {
      System.out.println(new StringBuilder().append("2147483648").reverse());
      System.out.println(new better().reverse(8463847412l));
    }
    // -123

    /**
     * 正常应该是像我这样判断，搞成 long，算完之后比较
     * 但是他们这些人很贼，利用了 int 不可能有：
     * 反转前 < integer.max / 10，
     * 但是加完 9 以后又超过 2147483647 的情况出现
     * 所以他这么写也没问题
     *
     * 你说的那种情况是这样的 7463847412 你最多 1 开头，2 开头就是个 long 了
     * 所以用 int 装这个数，不可能出现上面说的那种情况
     *
     * 但是我这个 long 装，更好理解，就是更浪费空间
     *
     * 还是好理解更加重要
     */
    public long reverse(long x) {
      // a * 10 + x < integer.maxvalue
      int max = Integer.MAX_VALUE / 10;
      int min = Integer.MIN_VALUE / 10;
      long res = 0;
      while (x != 0) {
        res = res * 10 + x % 10;
        if (res < Integer.MIN_VALUE || res > Integer.MAX_VALUE) {
          return 0;
        }
        x /= 10;
      }
      return res;
    }
  }
}
